/**
 * 商品评论数据模型
 */

const mongoose = require('mongoose');
const dbConfig = require('../config');

// 定义评论的 Schema
const reviewSchema = new mongoose.Schema({
    // ========== 基本信息 ==========
    // 评论ID（来自平台）
    reviewId: {
        type: String,
        required: true,
        index: true,
        unique: true  // 防止重复保存
    },
    
    // 任务名称（如 amazon-jp, amazon-de）
    taskName: {
        type: String,
        required: true,
        index: true
    },
    
    // 商品ASIN
    asin: {
        type: String,
        required: false,
        index: true
    },
    
    // 商品标题
    productTitle: {
        type: String,
        required: false
    },
    
    // 商品URL
    productUrl: {
        type: String,
        required: false
    },
    
    // ========== 评论信息 ==========
    // 评论者
    author: {
        type: String,
        required: false
    },
    
    // 评分（1-5星）
    rating: {
        type: Number,
        required: false,
        min: 1,
        max: 5,
        index: true
    },
    
    // 评分文本（如 "5.0 out of 5 stars"）
    ratingText: {
        type: String,
        required: false
    },
    
    // 评论标题
    title: {
        type: String,
        required: false,
        index: true
    },
    
    // 评论内容
    body: {
        type: String,
        required: false
    },
    
    // 评论日期（原始文本）
    date: {
        type: String,
        required: false
    },
    
    // 评论日期（解析后的Date对象）
    parsedDate: {
        type: Date,
        required: false,
        index: true
    },
    
    // ========== 互动信息 ==========
    // 有帮助的人数
    helpfulCount: {
        type: Number,
        required: false,
        default: 0,
        index: true
    },
    
    // 有帮助的文本
    helpfulText: {
        type: String,
        required: false
    },
    
    // ========== 验证信息 ==========
    // 是否是验证购买
    isVerifiedPurchase: {
        type: Boolean,
        required: false,
        default: false,
        index: true
    },
    
    // ========== 商品变体信息 ==========
    // 变体信息（如 Flavor Name, Size等）
    variantInfo: {
        type: String,
        required: false
    },
    
    // ========== 爬取信息 ==========
    // 爬取时间戳
    crawlTimestamp: {
        type: Date,
        required: false,
        default: Date.now,
        index: true
    },
    
    // 批次ID
    batchId: {
        type: String,
        required: false,
        index: true
    },
    
    // 搜索关键字
    searchKeyword: {
        type: String,
        required: false,
        index: true
    },
    
    // 项目索引（列表页中的位置）
    projectIndex: {
        type: Number,
        required: false
    },
    
    // Item索引（商品变体中的位置）
    itemIndex: {
        type: Number,
        required: false
    },
    
    // 额外的元数据
    metadata: {
        type: mongoose.Schema.Types.Mixed,
        required: false
    }
}, {
    // 自动管理 createdAt 和 updatedAt
    timestamps: true,
    
    // 集合名称
    collection: dbConfig.collections.reviews || 'reviews'
});

// ========== 索引 ==========
reviewSchema.index({ taskName: 1, createdAt: -1 });
reviewSchema.index({ asin: 1, createdAt: -1 });
reviewSchema.index({ rating: 1, createdAt: -1 });
reviewSchema.index({ isVerifiedPurchase: 1, rating: -1 });
reviewSchema.index({ helpfulCount: -1 });
reviewSchema.index({ batchId: 1, createdAt: -1 });
reviewSchema.index({ searchKeyword: 1, createdAt: -1 });
reviewSchema.index({ parsedDate: -1 });

// ========== 实例方法 ==========

/**
 * 解析评论日期字符串
 * @returns {Date|null} 解析后的日期
 */
reviewSchema.methods.parseReviewDate = function() {
    if (!this.date) return null;
    
    try {
        // 尝试解析不同格式的日期
        // 例如: "Reviewed in Japan on July 23, 2024"
        const dateMatch = this.date.match(/(\w+\s+\d+,\s+\d{4})/);
        if (dateMatch) {
            return new Date(dateMatch[1]);
        }
        
        // 其他格式...
        return new Date(this.date);
    } catch (error) {
        console.error('日期解析失败:', error.message);
        return null;
    }
};

// ========== 静态方法 ==========

/**
 * 批量保存评论（避免重复）
 * @param {Array} reviews - 评论数组
 * @returns {Promise<Object>} 保存结果统计
 */
reviewSchema.statics.saveBulk = async function(reviews) {
    if (!reviews || reviews.length === 0) {
        return { saved: 0, skipped: 0, failed: 0 };
    }
    
    let saved = 0;
    let skipped = 0;
    let failed = 0;
    
    for (const review of reviews) {
        try {
            // 使用 upsert 避免重复（基于 reviewId）
            await this.findOneAndUpdate(
                { reviewId: review.reviewId },
                { $set: review },
                { upsert: true, new: true }
            );
            saved++;
        } catch (error) {
            if (error.code === 11000) {
                // 重复键错误，跳过
                skipped++;
            } else {
                console.error(`保存评论失败 (${review.reviewId}):`, error.message);
                failed++;
            }
        }
    }
    
    return { saved, skipped, failed };
};

/**
 * 根据ASIN查询评论
 * @param {string} asin - 商品ASIN
 * @param {Object} options - 查询选项
 * @returns {Promise<Array>} 评论列表
 */
reviewSchema.statics.findByAsin = async function(asin, options = {}) {
    const { 
        minRating = null, 
        verifiedOnly = false,
        limit = 100,
        sort = { createdAt: -1 }
    } = options;
    
    const query = { asin };
    
    if (minRating) {
        query.rating = { $gte: minRating };
    }
    
    if (verifiedOnly) {
        query.isVerifiedPurchase = true;
    }
    
    return this.find(query)
        .sort(sort)
        .limit(limit)
        .exec();
};

// 创建模型
const Review = mongoose.model('Review', reviewSchema);

module.exports = Review;

